Partridge_Population_Manager.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, University of Aarhus
All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
#ifndef Partridge_Population_ManagerH
  #define Partridge_Population_ManagerH
//---------------------------------------------------------------------------
 
 
 
  #include <cmath>
  #include <stdio.h>
  #include <vector>
 
#include "../BatchALMaSS/ALMaSS_Setup.h"
 
#ifdef __UNIX
  #include "../BatchALMaSS/PopulationManager.h"
  #include "Partridge_Covey.h"
  #include "Partridge_All.h"
  #include "Partridge_Communication.h"
#else
  #include "../BatchALMaSS/PopulationManager.h"
  #include "Partridge_Covey.h"
  #include "Partridge_All.h"
  #include "Partridge_Communication.h"
#endif
 
class Partridge_struct;
class Partridge_Covey;
struct PartridgeCommunicationData;
class Partridge_Communication;
 
class CoverTempMap {
  public:
    ~CoverTempMap() { delete qualmap; }
    CoverTempMap(int a_lx, int a_ly) { m_maxx = (a_lx / 10); m_maxy = (a_ly / 10); qualmap = new double[m_maxx*m_maxy]; };
    double* qualmap;
    int m_maxx, m_maxy;
    void ZeroQual() { for (int i=0; i< m_maxx; i++) for (int j=0; j<m_maxy; j++) qualmap[i + j*m_maxx] = 0; }
    double GetQual(int a_x, int a_y) { return qualmap[(a_x / 10) + m_maxx*(a_y / 10)]; }
    void SetQual(int a_x, int a_y, double a_qual) { qualmap[(a_x / 10) + m_maxx*(a_y / 10)] = a_qual; }
    void AddQual(int a_x, int a_y, double a_qual) { qualmap[(a_x / 10) + m_maxx*(a_y / 10)] += a_qual; }
    double GetQualIndexed(int a_x, int a_y) { return qualmap[a_x + a_y * m_maxx]; }
    void SetQualIndexed(int a_x, int a_y, double a_qual) {qualmap[a_x + a_y * m_maxx] = a_qual; }
};
 
class Partridge_Population_Manager : public Population_Manager {
  //  double m_FoodNeed[200];
  //  double m_move_veg_structure[4][4];
  virtual void DoFirst();
  virtual void DoBefore();
  virtual void DoAfter();
  virtual void DoAlmostLast();
  virtual void DoLast();
  void TestShouldFlock();
  void Hunting(int p_chance);
  void HuntingGrid(int p_chance);
  void HuntingDifferentiatedBeetleBankArea( int a_pct );
  void CreateNestingCoverDensityMap( );
 
 
  // For looping through bobjects of a certain type.
  unsigned int m_loop_index;
  unsigned int m_loop_limit;
  int m_loop_ob_type;
  unsigned int m_Partridge_IDs;
  bool OpenParOutputFiles();
  bool CloseParOutputFiles();
  // Attributes
  bool m_ShouldFlock;
  void FillInFoodArray();
  int m_HatchSuccess;
  int m_maxx, m_maxy, m_halfwidth;
  // Output files
  FILE * ParAdMort; //
  FILE * ParJuvMort; //
  FILE * ParNoB; //
  FILE * ParClutches; //
  FILE * ParFlocks; //
  FILE * ParUnpairedMale; //
  FILE * NoHatchedPerYear; //
 
  int HabitatEvalPolyField( int a_field );
  double EvalHabitatQual(TTypesOfLandscapeElement a_cet, int a_poly);
  double m_HabitatQuality[300];
  virtual void Catastrophe();
  void MaleImmigration( void );
 
public:
  Partridge_Male* bad_guys[500];
  PartridgeCommunicationData* m_comms_data;
  Partridge_Communication m_messagecentre;
  CoverTempMap* m_territoryqualmap;
  CoverTempMap* m_nestingcovermap;
  k_factors * m_Ourkfactors;
  int m_Starved;
/*
  int m_Matured;
  int m_Eaten;
  int m_MaturedE;
  int m_EatenE;
*/
  bool FillCoveyNeigbourList(Partridge_Covey* a_covey, int a_distance, int a_x, int a_y);
  double TerrEvalPoly( TTypesOfLandscapeElement a_cet, int a_poly );
  int ClutchDensity( int x, int y, int radius);
 
 void AddStarved() {
    m_Starved++;
  }
 
 /* void AddMatured() {
    m_Matured++;
  }
 
  void AddEaten() {
    m_Eaten++;
  }
 
  void AddMaturedE() {
    m_MaturedE++;
  }
 
  void AddEatenE() {
    m_EatenE++;
  }
*/
 
  //  void SetFoodNeed(int i, double value) {m_FoodNeed[i]=value;}
  //  double GetFoodNeed(int i) {return m_FoodNeed[i];}
  //  void SetMoveVegStructure(int i, int j, double value) {m_move_veg_structure[i][j]=value;}
  //  double GetMoveVegStructure(int i, int j) {return m_move_veg_structure[i][j];}
 
  void WriteParAdMort( int a_min, int a_age, int a_sex, int a_cause );
  void WriteParJuvMort( int yr, int a_min, int a_age, int a_cause );
  void WriteParNoB( int a_min, int a_nob );
  void WriteParUnpairedMale( int a_min, int a_num );
  void WriteParClutches( int a_min, int a_num1, int a_num2 );
  void WriteParFlocks( int a_min, int a_size, int a_young );
  void WriteNoHatchedPerYear( int a_min, int a_num );
 
  void AddHatchSuccess( int sz ) {
    m_HatchSuccess += sz;
  }
 
  int SupplyPegPosx( int j ) {
    return dynamic_cast < Partridge_Covey * > ( TheArray[ pob_Covey ] [ j ] )->X();
  };
 
  int SupplyPegPosy( int j ) {
    return dynamic_cast < Partridge_Covey * > ( TheArray[ pob_Covey ] [ j ] )->Y();
  };
 
  int SupplyCovPosx( int j ) {
    return dynamic_cast < Partridge_Covey * > ( TheArray[ pob_Covey ] [ j ] )->XCenter();
  };
 
  int SupplyCovPosy( int j ) {
    return dynamic_cast < Partridge_Covey * > ( TheArray[ pob_Covey ] [ j ] )->YCenter();
  };
 
 
  void ObjectLoopInit( int ob_type );
  TAnimal * ObjectLoopFetch( void );
 
  void CreateObjects( int ob_type, Partridge_struct * data, int number );
  void CreateInitialObjects( int ob_type, int number );
  void CreateCloneObjects( int ob_type, AdultPartridge_struct * as );
  void AddObject( int ob_type, TAnimal * pTAo );
 
  virtual void Init( void );
  Partridge_Population_Manager( Landscape * a_map );
  virtual ~Partridge_Population_Manager( void );
  // Interface
  void UpdateNestingCoverMap();
  double GetNestingCoverDensity( int x, int y );
  double GetTerrQual( int x, int y );
  unsigned int GetNewID() {
    return ++m_Partridge_IDs;
  }
 
  bool SupplyShouldFlock() {
    return m_ShouldFlock;
  };
 
  void DissolveCovey( Partridge_Covey * a_covey );
  bool CoveyDissolveWeather();
  void DoSanityCheck(); // Is a de-bug method and can be removed at some point
  void DoMaleSanityCheck(); // ditto
    virtual void TheAOROutputProbe();
    virtual void TheRipleysOutputProbe(FILE* a_prb);
 
  double GetHabitatQuality (int a_day) {return m_HabitatQuality[a_day];}
 
};
 
#endif